import { getFullImageUrl, initBaseUrl, request } from '../../../utils/request';
import ImageViewer from '@/components/ImageViewer/ImageViewer.vue';
import { uploadFile } from '@/utils/request';
export default {
    components: {
        ImageViewer
    },
    data() {
        return {
            currentUser: 0,  //当前用户id

            // 用户信息（已登录时用）
            userInfo: {
                avatar: "/static/image/logo.jpg", // 替换为真实头像
                username: "用户123",
                selfDesc: "", // 自我描述
                gender: "", // 性别
                age: "", // 年龄
                height: "", // 身高
                isFollowed: false, // 添加关注状态属性
                followCount: 1623, // 关注数量
                id: 1,
                nickname: '未知用户'
            },
            currentTab: '动态',
            showImageViewer: false, // 查看图片弹窗显示状态

            currentBgImage: '', // 当前背景图片路径
            showBgPopup: false, // 背景弹窗显示状态

            dynamicList: [
                // {
                //     id: 1,
                //     avatar: '/static/image/logo.jpg',
                //     nickname: '碎碎梦',
                //     content: '因为想学游泳而聚集起来的四姐妹不过我是老师，其他三的成本会计不比较恐科技部的时刻基本上大家咯不见就怖恐惧的是博客避无可避苦逼加班加班副科级北京北方的不是位美女都是我的学生。',
                //     time: '07-01 10:12',
                //     images: ['/static/image/logo.jpg'], // 恢复图片路径
                //     comments: [
                //         {
                //             avatar: '/static/image/logo.jpg', // 添加头像
                //             nickname: '呼呼白日梦',
                //             content: '看完了，感觉真好',
                //             time: '03-23 21:08', // 添加时间
                //             likes: 165, // 添加点赞数
                //             liked: true, // 添加点赞状态
                //             isExpanded: false, // 新增：是否展开回复
                //             replies: [
                //                 {
                //                     replyer: '铁打的牛子',
                //                     content: '历史上有哪位最喜欢问斯达哪里开始的？'
                //                 },
                //                 {
                //                     replyer: '瓦罗大啧啧',
                //                     content: '回复 @铁打的牛子: 历史上有哪位最喜欢问斯达哪里开始的？'
                //                 },
                //                 {
                //                     replyer: '铁打的牛子',
                //                     content: '历史上有哪位最喜欢问斯达哪里开始的？'
                //                 },
                //                 {
                //                     replyer: '瓦罗大啧啧',
                //                     content: '回复 @铁打的牛子: 历史上有哪位最喜欢问斯达哪里开始的？'
                //                 },
                //                 {
                //                     replyer: '铁打的牛子',
                //                     content: '历史上有哪位最喜欢问斯达哪里开始的？'
                //                 }
                //             ]
                //         },
                //         {
                //             avatar: '/static/image/logo.jpg',
                //             nickname: '铁打的牛子',
                //             content: '历史上有哪位最喜欢问达哪里开始的？',
                //             time: '03-23 21:10',
                //             likes: 0,
                //             liked: false,
                //             replies: []
                //         },
                //         {
                //             avatar: '/static/image/logo.jpg',
                //             nickname: '瓦罗大啧啧',
                //             content: '历史上有哪位最喜欢问达哪里开始的？',
                //             time: '03-23 21:15',
                //             likes: 0,
                //             liked: false,
                //             replyTo: '铁打的牛子', // 添加回复标记
                //             replies: []
                //         }
                //     ],
                //     likes: 0, // 添加点赞数
                //     views: 568, // 添加浏览量
                //     liked: false, // 添加点赞状态
                //     isExpanded: false,
                //     shouldShowToggle: false
                // },
                // {
                //     id: 2,
                //     avatar: '/static/image/logo.jpg',
                //     nickname: '五罗大唠嗑',
                //     content: '青岛的兄弟姊妹们！！这次终于带着演唱会来啦！！',
                //     time: '07-01 10:12',
                //     images: ['/static/image/logo.jpg', '/static/image/logo.jpg', '/static/image/logo.jpg', '/static/image/logo.jpg'], // 恢复图片路径
                //     comments: [], // 无评论场景
                //     likes: 56, // 添加点赞数
                //     views: 1243, // 添加浏览量
                //     liked: false, // 添加点赞状态
                //     isExpanded: false,
                //     shouldShowToggle: false
                // }
            ],
            commentValue: '',
            reportReason: '',
            currentItem: null,
            replyTo: '',
            replyCommentIndex: -1,
            replyDynamicIndex: -1,
            replySubCommentIndex: -1, // 子评论索引，-1 表示不是回复子评论
            isCommentSending: false,
            albumData: {
                // 6月数据 - 3张图片
                "06月": [
                    { src: '/static/image/logo.jpg' },
                    { src: '/static/image/logo.jpg' },
                    { src: '/static/image/logo.jpg' }
                ],
                // 5月数据 - 6张图片
                "05月": [
                    { src: '/static/image/logo.jpg' },
                    { src: '/static/image/xz76.png' },
                    { src: '/static/image/z99.png' },
                    { src: '/static/image/xx.png' },
                    { src: '/static/image/xxz.png' },
                    { src: '/static/image/x117.png' }
                ],
                // 4月数据 - 4张图片
                "04月": [
                    { src: '/static/image/shenfenzheng.png' },
                    { src: '/static/image/logo.jpg' },
                    { src: '/static/image/xz1.png' },
                    { src: '/static/image/xz11.png' }
                ],
                // 3月数据 - 2张图片
                "03月": [
                    { src: '/static/image/xz12.png' },
                    { src: '/static/image/xz76.png' }
                ]
            },
            selectedPhotos: {}, // 选中的图片，格式: { "月份": [索引1, 索引2, ...] }
            isSelecting: false,
            showViewer: false, // 查看器显示状态
            viewerData: {}, // 查看器数据
            deletePopupVisible: {}, // 初始化为空对象
            targetUserId: 0, // 新增：目标用户ID

            currentPage: 1, // 新增：当前页码
            currentVideoUrl: '',
            showVideoView: false

        };
    },
    computed: {
        // 对月份进行排序（最新的在前）
        sortedMonths() {
            // 获取所有月份并排序
            return Object.keys(this.albumData).sort((a, b) => {
                // 假设月份格式为"MM月"，提取数字进行比较
                const monthA = parseInt(a);
                const monthB = parseInt(b);
                return monthB - monthA; // 降序排列
            });
        }
    },
    created() {
        // 页面创建时获取相册数据
        this.fetchAlbumData();
    },
    async onLoad(options) {
        this.currentUser = uni.getStorageSync('uid');
        // 新增：获取传入的user_id参数
        if (options && options.user_id) {
            this.targetUserId = parseInt(options.user_id);
            // 如果传入了user_id，获取该用户信息
            await this.fetchUserInfo(this.targetUserId);
        } else {
            // 如果没有传入user_id，获取当前登录用户信息
            await this.fetchUserInfo();
            this.targetUserId = this.userInfo.id;
        }
        // 加载动态列表
        this.getDynamicList();

    },
    methods: {
        openVideoViewer(item, mediaIndex) {
            this.currentVideoUrl = item.media[mediaIndex].url;
            this.showVideoView = true;
        },
        closeVideoPopup() {
            this.showVideoView = false;
        },
        getFullImageUrl,
        switchTab(tab) {
            this.currentTab = tab;
        },
        // 打开背景选择弹窗
        openBgPopup() {
            this.$refs.bgPopup.open();
        },

        // 关闭背景选择弹窗
        closeBgPopup() {
            this.$refs.bgPopup.close();
        },

        // 关闭举报菜单弹窗
        closeReportActionPopup() {
            this.$refs.reportActionPopup.close();
        },

        // 选择图片
        chooseImage(sourceType) {
            uni.chooseImage({
                count: 1, // 仅选择1张图片
                sourceType: [sourceType],
                success: async (res) => {
                    try {
                        uni.showLoading({ title: '上传中...' });
                        // 上传图片到服务器
                        const uploadRes = await uploadFile({
                            url: '/Common/uploadLocalOnly',
                            filePath: res.tempFilePaths[0],
                            name: 'file'
                        });
                        console.log('上传接口返回原始数据:', JSON.parse(uploadRes)); // 新增日志，查看原始返回数据
                        if (JSON.parse(uploadRes).code === 1) {
                            const imageUrl = JSON.parse(uploadRes).data.fullurl;
                            // 调用接口更新用户背景图片
                            const editRes = await request({
                                url: 'User/edit',
                                method: 'POST',
                                data: {
                                    background_image: imageUrl
                                }
                            });
                            console.log('更新接口返回数据:', editRes); // 新增日志，查看更新接口返回数据
                            if (editRes.code === 200) {
                                // 更新本地状态
                                this.currentBgImage = imageUrl;
                                this.userInfo.background_image = imageUrl; // 取消注释，同步更新用户信息
                                // 关闭弹窗
                                this.closeBgPopup();
                                // 显示成功提示
                                uni.showToast({
                                    title: '背景更换成功',
                                    icon: 'success'
                                });
                            } else {
                                // 显示更新失败提示
                                uni.showToast({
                                    title: '更新背景失败: ' + (editRes.msg || '未知错误'),
                                    icon: 'none'
                                });
                            }
                        } else {
                            uni.showToast({
                                title: (JSON.parse(uploadRes).msg || '未知错误'),

                                icon: 'none'
                            });
                        }
                    } catch (error) {
                        console.error('上传图片失败:', error);
                        uni.showToast({
                            title: '上传图片失败',
                            icon: 'none'
                        });
                    } finally {
                        uni.hideLoading();
                    }
                },
                fail: (err) => {
                    console.error('选择图片失败:', err);
                    uni.showToast({
                        title: '选择图片失败',
                        icon: 'none'
                    });
                }
            });
        },
        // 点赞功能
        async toggleLike(item) {
            console.log('点赞前状态:', item);
            // 禁用点赞按钮防止重复点击
            this.$set(item, 'isLikedDisabled', true);

            // 保存原始状态用于回滚
            const originalLiked = item.liked;
            const originalLikes = item.likes;

            // 乐观更新UI
            this.$set(item, 'liked', !originalLiked);
            this.$set(item, 'likes', originalLiked ? originalLikes - 1 : originalLikes + 1);

            // 同步图片查看器状态
            this.syncImageViewerLikeState(item);

            try {
                const res = await request({
                    url: 'discover/Like/toggle',
                    method: 'POST',
                    data: { post_id: item.post_id }
                });

                if (res.code === 1) {
                    // 根据后端返回的action确定最终状态
                    const isLiked = res.data.action === 'like';
                    // console.log('后端返回状态:', item.liked);
                    if (item.liked !== isLiked) {
                        this.$set(item, 'liked', isLiked);
                        this.$set(item, 'likes', isLiked ? item.likes + 1 : item.likes - 1);
                        this.syncImageViewerLikeState(item);
                    }
                } else {
                    // 请求失败回滚状态
                    this.rollbackLikeState(item, originalLiked, originalLikes);
                    uni.showToast({ title: res.data.msg || '操作失败', icon: 'none' });
                }
            } catch (error) {
                // 网络错误回滚状态
                this.rollbackLikeState(item, originalLiked, originalLikes);
                uni.showToast({ title: '网络请求失败', icon: 'none' });
            } finally {
                // 重新启用点赞按钮
                this.$set(item, 'isLikedDisabled', false);
            }
        },
        // 同步图片查看器的点赞状态
        syncImageViewerLikeState(item) {
            if (this.showImageViewer && item.images.includes(this.viewerData.imageUrl)) {
                this.$set(this.viewerData, 'liked', item.liked);
                this.$set(this.viewerData, 'likeCount', item.likes);
            }
        },

        // 回滚点赞状态
        rollbackLikeState(item, originalLiked, originalLikes) {
            this.$set(item, 'liked', originalLiked);
            this.$set(item, 'likes', originalLikes);
            this.syncImageViewerLikeState(item);
        },

        // 添加关注切换方法
        toggleFollow() {
            const newState = !this.userInfo.isFollowed;
            const change = newState ? 1 : -1;
            const actionText = newState ? '关注成功' : '取消关注';

            setTimeout(() => {
                this.userInfo.isFollowed = newState;
                // 更新关注数量
                this.userInfo.followCount = (this.userInfo.followCount || 0) + change;
                uni.hideLoading();
                uni.showToast({
                    title: `${actionText}`,
                    icon: 'success'
                });
            }, 500);
        },
        // 显示更多选项菜单
        showMoreOptions(item, index) {
            uni.showActionSheet({
                itemList: ['举报'],
                success: (res) => {
                    if (res.tapIndex === 0) {
                        this.openReportModal(item, index);
                    }
                }
            });
        },

        // 获取动态列表
        async getDynamicList() {
            uni.showLoading({ title: '加载中...' });
            try {
                const res = await request({
                    url: 'discover/Post/getList',
                    data: {
                        page: this.currentPage,
                        limit: 10,
                        user_id: this.targetUserId  // 通过user_id获取动态列表
                    }
                });

                if (res.code === 1) {
                    console.log("获取动态列表", res);
                    // 添加数据存在性检查
                    if (res.data && res.data.data && Array.isArray(res.data.data)) {
                        this.dynamicList = res.data.data.map(item => {
                            // 清理media_urls和media_types中的空格和引号
                            const cleanMediaUrls = item.media_urls ? item.media_urls.replace(/[`\s]/g, '') : '';
                            const cleanMediaTypes = item.media_types ? item.media_types.replace(/[`\s]/g, '') : '';

                            // 处理媒体数据
                            const media = cleanMediaUrls && cleanMediaTypes ? cleanMediaUrls.split(',').map((url, index) => ({
                                url: url.trim(),
                                type: cleanMediaTypes.split(',')[index]?.trim() || 'image'
                            })) : [];

                            // 兼容原有图片数组
                            const images = item.image_urls ?
                                item.image_urls.split(',').map(url => url.trim()) :
                                (cleanMediaUrls ?
                                    cleanMediaUrls.split(',').filter((_, index) =>
                                        cleanMediaTypes.split(',')[index]?.trim() === 'image'
                                    ).map(url => url.trim()) :
                                    []
                                );

                            // 视频数组
                            const videos = cleanMediaUrls && cleanMediaTypes ?
                                cleanMediaUrls.split(',').filter((_, index) =>
                                    cleanMediaTypes.split(',')[index]?.trim() === 'video'
                                ).map(url => url.trim()) :
                                [];

                            return {
                                ...item,
                                media,
                                images,
                                videos,
                                liked: Boolean(item.is_liked),
                                likes: Number(item.like_count) || 0,
                                isExpanded: false,
                                shouldShowToggle: false,
                                comments: [],
                                isLikedDisabled: false,
                                user_id: item.user_id,
                            };
                        });
                        this.checkContentLength();
                        // 加载动态列表后更新相册数据
                        this.fetchAlbumData();
                    } else {
                        console.warn('动态列表数据格式不正确:', res.data);
                        this.dynamicList = [];
                    }
                }
            } catch (error) {
                console.error('获取动态列表失败:', error);
                uni.showToast({ title: '获取动态失败', icon: 'none' });
            } finally {
                uni.hideLoading();
            }
        },
        // 新增：格式化时间方法
        formatTime(dateString) {
            const date = new Date(dateString);
            const month = date.getMonth() + 1;
            const day = date.getDate();
            const hours = date.getHours().toString().padStart(2, '0');
            const minutes = date.getMinutes().toString().padStart(2, '0');
            return `${month}-${day} ${hours}:${minutes}`;
        },
        // 删除动态
        openDeleteModal(index) {
            this.$refs[`deletePopup${index}`][0].open();
        },

        // 确认删除动态
        async confirmDelete(item, index) {
            try {
                const res = await request({
                    url: 'discover/Post/delete',
                    method: 'POST',
                    data: {
                        post_id: item.post_id
                    }
                });
                console.log('删除动态接口返回数据:', res); // 新增日志，查看接口返回数据

                if (res.code === 1) {
                    this.dynamicList.splice(index, 1);
                    this.$refs[`deletePopup${index}`][0].close();
                    uni.showToast({ title: '删除成功', icon: 'success' });
                } else {
                    uni.showToast({ title: res.msg || '删除失败', icon: 'none' });
                }
            } catch (error) {
                console.error('删除失败:', error);
                uni.showToast({ title: '网络错误', icon: 'none' });
            } finally {
                uni.hideLoading();
            }
        },


        // 打开举报弹窗
        openReportModal(item, index) {
            // 关闭底部菜单弹窗
            this.closeBgPopup();
            // 存储当前操作的动态项
            this.currentItem = item;
            this.currentItemIndex = index;
            // 重置举报原因
            this.reportReason = '';
            // 打开举报弹窗
            this.$nextTick(() => {
                this.$refs[`reportPopup${index}`][0].open();
            });
        },
        // 提交举报
        submitReport(item, index) {
            if (!this.reportReason.trim()) return

            // 显示加载提示
            uni.showLoading({
                title: '提交中...',
                mask: true
            })

            // 调用后端接口
            request({
                url: 'discover/report/submit',
                method: 'POST',
                data: {
                    post_id: item.post_id,
                    report_reason: this.reportReason
                }
            }).then(res => {
                uni.hideLoading()
                if (res.code === 200) {
                    uni.showToast({
                        title: '举报提交成功，等待审核',
                        icon: 'success',
                        duration: 2000
                    })
                } else {
                    uni.showToast({
                        title: res.msg || '举报提交失败',
                        icon: 'none',
                        duration: 2000
                    })
                }
                // 不管成功失败都关闭弹窗
                this.closePopup('reportPopup', index)

                this.closeReportActionPopup()
                // 举报后清空输入框
                this.reportReason = ''
            }).catch(err => {
                uni.hideLoading()
                uni.showToast({
                    title: '网络错误，请稍后重试',
                    icon: 'none',
                    duration: 2000
                })
                console.error('提交举报失败:', err)
                // 网络错误也关闭弹窗
                this.closePopup('reportPopup', index)
                // 清空输入框
                this.reportReason = ''
            })
        },
        // 打开评论弹窗
        openCommentModal(item, index) {
            console.log('打开评论弹窗', item, index);
            this.currentItem = item;
            this.commentValue = '';
            this.replyTo = '';
            this.replyCommentIndex = -1;
            this.replySubCommentIndex = -1;
            this.replyDynamicIndex = -1;
            this.$nextTick(() => {
                console.log('即将打开弹窗', index);
                this.$refs[`commentPopup${index}`][0].open();
                console.log('弹窗已打开', index);
            });
            // 获取评论列表
            this.getComments(item.post_id, index, 1);

            // 如果有更多评论，继续加载
            const loadAllComments = () => {
                if (item.pagination && item.pagination.current_page < item.pagination.last_page) {
                    const nextPage = item.pagination.current_page + 1;
                    this.getComments(item.post_id, index, nextPage).then(() => {
                        loadAllComments();
                    });
                }
            };
            loadAllComments();
        },


        // 获取评论列表
        getComments(post_id, index, page = 1) {
            return new Promise((resolve) => {
                request({
                    url: `discover/Comment/getList?post_id=${post_id}&page=${page}`,
                    method: 'GET',
                    success: (res) => {
                        console.log("获取评论列表", res);
                        // 将 res.data.code 改为 res.code
                        if (res.data.code === 1) {
                            if (this.dynamicList && this.dynamicList[index]) {
                                const comments = Array.isArray(res.data.data.data) ? res.data.data.data : [];

                                // 添加调试日志，打印后端返回的原始数据
                                console.log('后端返回的原始评论数据:', JSON.parse(JSON.stringify(comments)));
                                // 处理评论数据
                                comments.forEach(comment => {
                                    comment.time = comment.comment_time;
                                    comment.liked = Boolean(comment.is_liked);
                                    comment.likes = Number(comment.like_count) || 0;
                                    // 确保user_id字段存在，用于回复评论时获取被回复用户ID
                                    // 从后端返回的数据中获取user_id，如果不存在则使用id字段
                                    // 确保主评论有user_id字段，如果没有则从其他字段获取
                                    if (!comment.user_id && comment.id) {
                                        comment.user_id = comment.id;
                                    }
                                    // 如果仍然没有user_id，则记录错误日志
                                    if (!comment.user_id) {
                                        console.error('主评论缺少user_id字段:', comment);
                                    }
                                    // 添加调试日志，检查user_id字段
                                    console.log('处理后的评论对象:', { commentId: comment.comment_id, userId: comment.user_id, originalComment: JSON.parse(JSON.stringify(comment)) });
                                    // 添加 isExpanded 属性并初始化为 false
                                    comment.isExpanded = false;

                                    // 处理回复数据
                                    if (comment.replies && comment.replies.length > 0) {
                                        comment.replies.forEach(reply => {
                                            reply.isExpanded = false; // 确保回复也有 isExpanded 属性
                                            // 确保回复内容格式正确
                                            if (!reply.content.startsWith('@')) {
                                                reply.content = `${reply.reply_nickname}：${reply.formatted_content}`;
                                            }
                                        });
                                    }
                                    else {
                                        comment.replies = []; // 确保 replies 存在
                                    }
                                });

                                if (page === 1) {
                                    this.$set(this.dynamicList[index], 'comments', comments);
                                } else {
                                    // 确保不会重复添加相同评论
                                    const existingIds = new Set(this.dynamicList[index].comments.map(c => c.comment_id));
                                    const newComments = comments.filter(c => !existingIds.has(c.comment_id));
                                    const updatedComments = [...this.dynamicList[index].comments, ...newComments];
                                    this.$set(this.dynamicList[index], 'comments', updatedComments);
                                }

                                // 存储分页信息
                                this.$set(this.dynamicList[index], 'pagination', {
                                    total: res.data.data.total,
                                    per_page: res.data.data.per_page,
                                    current_page: res.data.data.current_page,
                                    last_page: res.data.data.last_page
                                });

                                // 不再更新评论总数，统一使用Post/getList接口返回的comment_count
                                console.log('不再更新评论总数，使用Post/getList接口返回的comment_count:', {
                                    oldCount: this.dynamicList[index].comment_count,
                                    newCount: this.dynamicList[index].comment_count,
                                    postId: post_id
                                });
                            }
                        } else {
                            uni.showToast({ title: res.data.msg, icon: 'none' });
                        }
                        resolve();
                    },
                    fail: () => {
                        uni.showToast({ title: '获取评论列表失败', icon: 'none' });
                        resolve();
                    }
                });
            });
        },

        // 加载更多评论

        loadMoreComments(event, index) {
            const item = this.dynamicList[index];
            // 检查是否有分页信息，并且当前页小于最后一页
            if (item.pagination && item.pagination.current_page < item.pagination.last_page) {
                const nextPage = item.pagination.current_page + 1;
                this.getComments(item.post_id, index, nextPage);
            }
        },

        // 获取可见回复
        getVisibleReplies(comment) {
            if (!comment || !comment.replies) return [];
            const showAll = comment.isExpanded || false;
            return showAll ? comment.replies : comment.replies.slice(0, 2);
        },
        // 关闭弹窗通用方法
        closePopup(refName, index) {
            if (refName === 'commentPopup') {
                this.$refs[`commentPopup${index}`][0].close();
                this.commentValue = '';
                this.replyTo = '';
                this.replyCommentIndex = -1;
                this.replyDynamicIndex = -1;
            } else if (refName === 'deletePopup') {
                this.$refs[`deletePopup${index}`][0].close();
            } else if (refName === 'reportPopup') {
                // 如果是举报弹窗，使用更新的ref格式
                this.$refs[`reportPopup${index}`][0].close();
                // 重置举报原因
                this.reportReason = '';
            }
        },
        // 回复评论
        replyComment(comment, cIndex, dIndex) {
            console.log("回复评论", comment, cIndex, dIndex)
            // 设置回复对象
            this.replyTo = comment.reply_nickname ? comment.reply_nickname : comment.nickname;
            // 区分是主评论还是子评论
            if (comment.comment_id) {
                // 主评论
                this.replyCommentIndex = cIndex;
                this.replySubCommentIndex = -1; // 重置子评论索引
            } else if (comment.reply_id) {
                // 子评论
                this.replyCommentIndex = dIndex; // 存储主评论索引
                this.replySubCommentIndex = cIndex; // 存储子评论索引
            }

            this.replyDynamicIndex = dIndex;

            // 清空评论输入框的值
            this.commentValue = '';

            // 确保在弹窗完全渲染后执行滚动
            this.$nextTick(() => {
                // 滚动到评论输入框（小程序兼容版本）
                const query = uni.createSelectorQuery().in(this);
                query.select('.comment-input').boundingClientRect();
                query.selectViewport().scrollOffset();
                query.exec((res) => {
                    if (res && res[0] && res[1]) {
                        const inputTop = res[0].top;
                        const scrollTop = res[1].scrollTop;
                        uni.pageScrollTo({
                            scrollTop: scrollTop + inputTop - 100,
                            duration: 300
                        });
                    }
                });
            });
        },
        // 切换回复展开状态
        toggleReplyExpand(comment) {
            // 切换展开/收起状态
            comment.isExpanded = !comment.isExpanded;

            // 添加平滑滚动效果（可选）
            this.$nextTick(() => {
                const replyListEl = document.querySelector(`.reply-list`);
                if (replyListEl && comment.isExpanded) {
                    replyListEl.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
                }
            });
        },



        // 显示更多选项菜单
        showMoreOptions(item, index) {
            // 存储当前操作的动态项
            this.currentItem = item;
            this.currentItemIndex = index;
            // 打开举报菜单弹窗
            this.$refs.reportActionPopup.open();
        },

        // 关闭底部菜单弹窗
        closeBgPopup() {
            if (this.$refs.bgPopup) {
                this.$refs.bgPopup.close();
            }
        },

        // 点赞回复
        // async likeReply(comment, rIndex) {
        //     try {
        //         this.isCommentSending = true;
        //         const reply = comment.replies[rIndex];
        //         const res = await request({
        //             url: 'discover/Comment/like',
        //             method: 'POST',
        //             data: {
        //                 comment_id: reply.reply_id,
        //                 type: reply.liked ? 0 : 1
        //             }
        //         });
        //         if (res.code === 1) {
        //             reply.liked = !reply.liked;
        //             reply.likes = reply.liked ? (reply.likes || 0) + 1 : Math.max(0, (reply.likes || 0) - 1);
        //             uni.showToast({ title: reply.liked ? '点赞成功' : '取消点赞', icon: 'none' });
        //         } else {
        //             uni.showToast({ title: res.msg || '操作失败', icon: 'none' });
        //         }
        //     } catch (error) {
        //         console.error('点赞回复失败:', error);
        //         uni.showToast({ title: '网络错误', icon: 'none' });
        //     } finally {
        //         this.isCommentSending = false;
        //     }
        // },
        // 发送评论
        async sendComment(item, replyTo, cIndex, dIndex) {
            console.log("发送评论", item)
            if (!this.commentValue.trim()) return;
            if (this.isCommentSending) return;

            this.isCommentSending = true;
            // 保存当前评论索引用于后续调用loadMoreReplies
            const currentCommentIndex = this.replyCommentIndex;

            try {
                let apiUrl = 'discover/Comment/create';
                let postData = {
                    post_id: item.post_id,
                    content: this.commentValue.trim()
                };

                // 如果是回复评论
                if (this.replyDynamicIndex !== -1) {
                    let comment;
                    console.log("回复评论索引", this.replyCommentIndex, this.replySubCommentIndex)
                    // 区分是回复主评论还是子评论
                    if (item.comments && item.comments[this.replyCommentIndex]) {
                        if (this.replySubCommentIndex === -1) {
                            // 回复主评论
                            comment = item.comments[this.replyCommentIndex];
                        } else {
                            // 回复子评论
                            if (item.comments[this.replyCommentIndex].replies) {
                                comment = item.comments[this.replyCommentIndex].replies[this.replySubCommentIndex];
                            }
                        }
                    }

                    // 检查comment是否存在，如果不存在则不发送请求
                    if (!comment) {
                        uni.showToast({ title: '评论信息不完整', icon: 'none' });
                        this.isCommentSending = false;
                        return;
                    }

                    console.log("回复评论发送", comment)
                    // 添加调试日志，检查comment对象的属性
                    console.log('回复评论时的comment对象:', JSON.parse(JSON.stringify(comment)));
                    apiUrl = 'discover/Comment/reply';

                    // 提取用户实际输入的内容（去掉"@用户名 "部分）
                    const userContent = this.commentValue.replace(`@${this.replyTo}`, '').trim();

                    // 检查用户输入内容是否为空
                    if (!userContent) {
                        uni.showToast({ title: '评论内容不能为空', icon: 'none' });
                        this.isCommentSending = false;
                        return;
                    }

                    // 格式化内容
                    const formattedContent = `${userContent}`;

                    // 确定父评论ID和被回复用户ID
                    // 如果是回复一条回复，需要使用回复的parent_comment_id作为父评论ID
                    // 被回复用户ID应该是回复的reply_user_id
                    let parentCommentId, beRepliedUserId;

                    console.log('回复评论对象:', comment);

                    if (comment.reply_id) {
                        // 回复子评论
                        parentCommentId = comment.parent_comment_id;
                        beRepliedUserId = comment.reply_user_id || comment.be_replied_user_id;
                        console.log('回复子评论:', { parentCommentId, beRepliedUserId, reply_user_id: comment.reply_user_id, be_replied_user_id: comment.be_replied_user_id });
                    } else {
                        // 回复主评论
                        parentCommentId = comment.comment_id;
                        // 添加详细的调试日志
                        console.log('回复主评论详细信息:', {
                            comment: JSON.parse(JSON.stringify(comment)),
                            user_id_source: comment.user_id,
                            be_replied_user_id_source: comment.be_replied_user_id,
                            user_id_type: typeof comment.user_id,
                            be_replied_user_id_type: typeof comment.be_replied_user_id
                        });
                        // 确保能正确获取被回复用户的ID
                        // 临时修复：如果comment.user_id不存在，尝试从其他字段获取或使用默认值
                        if (!comment.user_id) {
                            console.warn('comment.user_id is missing, attempting to use a default value or derive from other fields');
                            // 尝试从userInfo中获取当前登录用户的ID
                            if (this.userInfo && this.userInfo.id) {
                                comment.user_id = this.userInfo.id;
                            } else {
                                // 如果无法获取当前用户ID，使用一个默认的管理员ID
                                // 注意：这只是一个临时修复，实际应用中应该确保能正确获取用户ID
                                comment.user_id = 1; // 假设管理员ID为1
                            }
                        }
                        beRepliedUserId = comment.user_id || comment.be_replied_user_id;
                        console.log('回复主评论:', { parentCommentId, beRepliedUserId, user_id: comment.user_id, be_replied_user_id: comment.be_replied_user_id });
                    }

                    // 添加调试日志
                    console.log('参数计算结果:', { parentCommentId, beRepliedUserId, comment });

                    // 检查必需参数是否有效
                    console.log('参数检查:', { parentCommentId, beRepliedUserId, formattedContent });
                    if (!parentCommentId || !beRepliedUserId || !formattedContent) {
                        uni.showToast({ title: '评论参数不完整', icon: 'none' });
                        this.isCommentSending = false;
                        return;
                    }

                    postData = {
                        parent_comment_id: parentCommentId,
                        be_replied_user_id: beRepliedUserId,
                        content: formattedContent
                    };
                }

                const res = await request({
                    url: apiUrl,
                    method: 'POST',
                    data: postData
                });

                // 确保res对象存在且有code属性
                if (res && res.code === 1) {
                    uni.showToast({ title: '发送成功' });

                    // 立即在前端显示新评论
                    const newComment = {
                        reply_id: res.data.reply_id, // 确保有reply_id字段
                        comment_id: this.replyDynamicIndex !== -1 ? res.data.reply_id : res.data.comment_id,
                        content: this.replyDynamicIndex !== -1 ? `${this.userInfo.nickname || '匿名用户'} ${this.commentValue.trim()}` : this.commentValue.trim(),
                        nickname: this.userInfo.nickname || '匿名用户',
                        avatar: this.userInfo.avatar || '/static/image/logo.jpg',
                        time: new Date().toLocaleString(),
                        likes: 0,
                        liked: false,
                        replies: [],
                        reply_count: 0,
                        // 设置父评论ID
                        parent_comment_id: this.replySubCommentIndex !== -1 && item.comments && item.comments[this.replyCommentIndex] ? item.comments[this.replyCommentIndex].parent_comment_id : null
                    };

                    // 如果是回复评论
                    if (this.replyDynamicIndex !== -1) {
                        // 回复主评论或子评论
                        const parentComment = item.comments && item.comments[this.replyCommentIndex] ? item.comments[this.replyCommentIndex] : null;
                        if (parentComment) {
                            // 不再直接添加到replies数组，而是依赖loadMoreReplies来更新
                            this.$set(parentComment, 'reply_count', parentComment.reply_count + 1);
                            // 更新评论总数，及时显示+1
                            this.$set(item, 'comment_count', item.comment_count + 1);
                            console.log('更新评论总数，及时显示+1:', {
                                oldCount: item.comment_count - 1,
                                newCount: item.comment_count,
                                postId: item.post_id
                            });

                            // 立即调用loadMoreReplies确保新回复显示
                            this.loadMoreReplies(parentComment);
                        }
                    } else {
                        // 添加新评论到评论列表顶部
                        if (!item.comments) {
                            this.$set(item, 'comments', []);
                        }
                        item.comments.unshift(newComment);

                        // 更新评论总数，及时显示+1
                        this.$set(item, 'comment_count', item.comment_count + 1);
                        console.log('更新评论总数，及时显示+1:', {
                            oldCount: item.comment_count - 1,
                            newCount: item.comment_count,
                            postId: item.post_id
                        });
                    }

                    // 关键修改：等待getComments完成
                    await this.getComments(item.post_id, dIndex, 1);

                    // 如果是回复评论，确保加载所有回复
                    if (currentCommentIndex !== -1) {
                        this.$nextTick(() => {
                            // 确保dynamicList[dIndex]存在且有comments属性
                            if (this.dynamicList[dIndex] && this.dynamicList[dIndex].comments) {
                                const comment = this.dynamicList[dIndex].comments[currentCommentIndex];
                                if (comment) {
                                    this.loadMoreReplies(comment);
                                }
                            }
                        });
                    }

                    // 强制刷新视图
                    this.$forceUpdate();
                } else {
                    // 请求失败回滚乐观更新
                    if (this.replyCommentIndex !== -1 && comment) {
                        comment.replies.shift();
                    } else if (this.dynamicList[dIndex] && this.dynamicList[dIndex].comments) {
                        this.dynamicList[dIndex].comments.shift();
                    }
                    // 优先使用res.msg，如果不存在则使用res.data.msg
                    console.log("发送评论失败", res.msg)

                    const errorMsg = res.msg || res.data.msg || '发布失败';
                    uni.showToast({ title: errorMsg, icon: 'none' });
                }
            } catch (error) {
                // 捕获异常时res可能未定义，直接使用默认提示
                uni.showToast({ title: '发送失败', icon: 'none' });
            } finally {
                // 重置状态
                this.commentValue = '';
                this.replyTo = '';
                this.replyCommentIndex = -1;
                this.replyDynamicIndex = -1;
                this.isCommentSending = false;
            }
        },
        // 新增loadMoreReplies方法
        async loadMoreReplies(comment) {
            try {
                const res = await request({
                    url: `discover/Comment/getReplies?comment_id=${comment.comment_id}`,
                    method: 'GET'
                });
                console.log("获取回复新增loadMoreReplies方法", res)
                if (res.code === 1) {
                    const replies = res.data.replies || [];

                    // 格式化回复内容，保留后端返回的'回复 @用户名: '格式
                    const formattedReplies = replies.map(reply => {
                        // 直接使用后端返回的formatted_content
                        if (reply.formatted_content) {
                            // 使用手机号格式化显示
                            const displayPhone = reply.reply_phone ? reply.reply_phone.replace(/(\d{3})\d{4}(\d{4})/, '$1****$2') : reply.reply_nickname;
                            // 保留后端返回的'回复 @用户名: '格式
                            reply.content = `${displayPhone}： ${reply.formatted_content}`;
                        }
                        return reply;
                    });

                    // 更新回复列表，追加新回复而不是替换
                    if (!comment.replies) {
                        this.$set(comment, 'replies', formattedReplies);
                    } else {
                        // 确保不会重复添加相同回复
                        const existingIds = new Set(comment.replies.map(r => r.reply_id));
                        const newReplies = formattedReplies.filter(r => !existingIds.has(r.reply_id));
                        const updatedReplies = [...comment.replies, ...newReplies];
                        this.$set(comment, 'replies', updatedReplies);
                    }
                } else {
                    uni.showToast({ title: res.data.msg, icon: 'none' });
                }
            } catch (error) {
                uni.showToast({ title: '加载回复失败', icon: 'none' });
            }
        },

        // 修改viewAllReplies方法
        viewAllReplies(comment) {
            if (!comment) return;
            this.$set(comment, 'isExpanded', !comment.isExpanded);

            // 如果展开且有更多回复未加载
            if (comment.isExpanded && comment.reply_count > comment.replies.length) {
                this.loadMoreReplies(comment);
            }
        },


        // 点赞回复
        async likeReply(comment, rIndex) {
            try {
                this.isCommentSending = true;
                const reply = comment.replies[rIndex];
                const res = await request({
                    url: 'discover/Comment/like',
                    method: 'POST',
                    data: {
                        comment_id: reply.reply_id,
                        type: reply.liked ? 0 : 1
                    }
                });
                if (res.code === 1) {
                    reply.liked = !reply.liked;
                    reply.likes = reply.liked ? (reply.likes || 0) + 1 : Math.max(0, (reply.likes || 0) - 1);
                    uni.showToast({ title: reply.liked ? '点赞成功' : '取消点赞', icon: 'none' });
                } else {
                    uni.showToast({ title: res.msg || '操作失败', icon: 'none' });
                }
            } catch (error) {
                console.error('点赞回复失败:', error);
                uni.showToast({ title: '网络错误', icon: 'none' });
            } finally {
                this.isCommentSending = false;
            }
        },

        // 评论点赞
        async likeComment(comment, cIndex, dIndex) {
            // 检查必要参数
            if (!comment.comment_id || comment.isLikedDisabled) return;

            // 禁用点赞按钮防止重复点击
            this.$set(comment, 'isLikedDisabled', true);

            // 保存原始状态用于回滚
            const originalLiked = comment.liked;
            const originalLikes = comment.likes;

            // 乐观更新UI（立即改变前端状态）
            this.$set(comment, 'liked', !originalLiked);
            this.$set(comment, 'likes', originalLiked ? originalLikes - 1 : originalLikes + 1);

            // 强制UI更新
            this.$forceUpdate();

            try {
                const res = await request({
                    url: 'discover/Like/toggle',
                    method: 'POST',
                    data: {
                        comment_id: comment.comment_id,
                        type: 'comment'  // 明确指定类型为评论点赞
                    }
                });

                if (res.code === 1) {
                    // 根据后端返回的action确认状态
                    const isLiked = res.data.action === 'like';

                    // 如果前端和后端状态不一致，则修正
                    if (comment.liked !== isLiked) {
                        this.$set(comment, 'liked', isLiked);
                        this.$set(comment, 'likes', isLiked ? originalLikes + 1 : originalLikes - 1);
                    }
                } else {
                    // 请求失败回滚状态
                    this.$set(comment, 'liked', originalLiked);
                    this.$set(comment, 'likes', originalLikes);
                    uni.showToast({ title: res.msg, icon: 'none' });
                }
            } catch (error) {
                // 网络错误回滚状态
                this.$set(comment, 'liked', originalLiked);
                this.$set(comment, 'likes', originalLikes);
                uni.showToast({ title: '操作失败', icon: 'none' });
            } finally {
                // 重新启用点赞按钮
                this.$set(comment, 'isLikedDisabled', false);
            }
        },
        onShare(item) {
            uni.share({
                title: item.content,
                imageUrl: item.images && item.images.length > 0 ? item.images[0] : '/static/image/logo.jpg',
                success: () => {
                    uni.showToast({ title: '分享成功' })
                },
                fail: () => {
                    // uni.showToast({ title: '分享失败，该功能暂未开放', icon: 'none' })
                }
            })
        },

        // 分享给朋友
        onShareAppMessage() {
            // if (this.currentShareItem) {
            //     let title = this.currentShareItem.content
            //         ? this.currentShareItem.content.substring(0, 30) + '...'
            //         : '来自Online Didi的分享';
            //     let imageUrl = '/static/image/logo.jpg';
            //     if (this.currentShareItem.media && this.currentShareItem.media.length > 0 && this.currentShareItem.media[0].type === 'image') {
            //         imageUrl = getFullImageUrl(this.currentShareItem.media[0].url);
            //     }
            //     return {
            //         title: title,
            //         path: `/pages/discover/index?id=${this.currentShareItem.post_id || ''}`,
            //         imageUrl: imageUrl
            //     };
            // }
            return {
                title: '发现有趣的动态内容，快来看看吧！',
                path: '/pages/discover/index',
                imageUrl: this.getFullImageUrl('/index/logo.jpg')
            };
        },

        // 分享到朋友圈
        onShareTimeline() {
            if (this.currentShareItem) {
                let title = this.currentShareItem.content
                    ? this.currentShareItem.content.substring(0, 30) + '...'
                    : '来自Online Didi的分享';
                let imageUrl = '/static/image/logo.jpg';
                if (this.currentShareItem.media && this.currentShareItem.media.length > 0 && this.currentShareItem.media[0].type === 'image') {
                    imageUrl = getFullImageUrl(this.currentShareItem.media[0].url);
                }
                return {
                    title: title,
                    query: `from=timeline&id=${this.currentShareItem.post_id || ''}`,
                    imageUrl: imageUrl
                };
            }
            return {
                title: '有有趣的动态内容，一起来分享吧！',
                query: 'from=timeline',
                imageUrl: this.getFullImageUrl('/index/logo.jpg')
            };
        },
        // 图片预览
        openImageViewer(item, imgIndex) {
            this.viewerData = {
                avatar: item.avatar,
                nickname: item.nickname,
                imageUrl: item.images[imgIndex],
                content: item.content,
                likeCount: item.likes,
                commentCount: item.comment_count,
                liked: item.liked
            };
            // 显示查看器
            this.showImageViewer = true;
        },
        handleImageLike() {
            // 找到当前查看的动态项
            const currentItem = this.dynamicList.find(item =>
                item.images.includes(this.viewerData.imageUrl)
            );

            if (currentItem) {
                // 直接调用toggleLike方法，确保逻辑统一
                this.toggleLike(currentItem);
            }
        },
        handleImageComment() {
            // 关闭图片查看器并打开评论弹窗
            this.showImageViewer = false;
            const currentItem = this.dynamicList.find(item => item.images.includes(this.viewerData.imageUrl));
            if (currentItem) {
                const index = this.dynamicList.indexOf(currentItem);
                this.openCommentModal(currentItem, index);
            }
        },

        // 评论展开收起
        toggleContentExpand(item, index) {
            this.$set(item, 'isExpanded', !item.isExpanded);
            if (!item.isExpanded) {
                this.$nextTick(() => {
                    setTimeout(() => {
                        this.checkSingleContentLength(item, index);
                    }, 300);
                });
            }
        },

        // 增强checkContentLength方法，完善重试机制
        checkContentLength() {
            console.log('开始检查动态内容长度');

            // 初次检查
            this.$nextTick(() => {
                setTimeout(() => {
                    if (this.dynamicList && this.dynamicList.length > 0) {
                        console.log(`初次检查 ${this.dynamicList.length} 条动态内容`);
                        this.dynamicList.forEach((item, index) => {
                            this.checkSingleContentLength(item, index);
                        });
                    }
                }, 300);
            });

            // 增强的重试机制，使用更多重试次数和递增延迟
            const checkWithRetry = (retryCount = 0) => {
                // 根据重试次数递增延迟时间
                const delay = 300 + (retryCount * 200);

                setTimeout(() => {
                    if (this.dynamicList && this.dynamicList.length > 0) {
                        console.log(`第${retryCount + 1}次重试检查动态内容`);
                        this.$nextTick(() => {
                            this.dynamicList.forEach((item, index) => {
                                // 重试检查更广泛的内容范围，降低阈值提高检出率
                                if ((!item.shouldShowToggle && item.content && item.content.length > 80) ||
                                    (item.shouldShowToggle && item.isExpanded && !item.contentExpandedChecked)) {
                                    console.log(`重试检查动态 ${item.post_id} 的内容高度`);
                                    this.checkSingleContentLength(item, index);
                                }
                            });
                        });
                    }
                }, delay);

                // 增加重试次数到5次，确保所有内容都有足够的检查机会
                if (retryCount < 4) {
                    setTimeout(() => checkWithRetry(retryCount + 1), delay + 300);
                }
            };

            // 启动重试检查
            setTimeout(() => checkWithRetry(), 500);
        },

        // 增强的单个动态内容高度检查方法
        checkSingleContentLength(item, index) {
            // 检查item和item.content是否存在
            if (!item || !item.content) {
                console.warn(`动态 ${item?.post_id} 的内容不存在`);
                return;
            }

            // 先根据内容长度做一个简单的预判断，降低阈值提高检出率
            if (item.content.length > 150) {
                // 对于较长的内容，直接设置shouldShowToggle为true
                this.$set(item, 'shouldShowToggle', true);
                console.log(`动态 ${item.post_id} 内容长度 ${item.content.length} > 150，直接显示展开按钮`);
                return;
            }

            this.$nextTick(() => {
                try {
                    // 尝试使用多种方式查询元素
                    const elementId = `content_${index}`;
                    const query = uni.createSelectorQuery().in(this);

                    // 先尝试通过ID查询
                    query.select(`#${elementId}`).boundingClientRect().exec((res) => {
                        if (res && res[0]) {
                            const maxHeight = 138; // 3行高度(rpx)
                            const shouldShow = res[0].height > maxHeight;
                            this.$set(item, 'shouldShowToggle', shouldShow);
                            console.log(`动态 ${item.post_id} 内容高度: ${res[0].height}, 显示展开按钮: ${shouldShow}`);
                        } else {
                            // 如果通过ID查询失败，使用后备判断，进一步降低阈值
                            console.warn(`未获取到动态 ${item.post_id} 的内容高度，通过ID查询失败`);
                            if (item.content.length > 80) {
                                this.$set(item, 'shouldShowToggle', true);
                                console.log(`动态 ${item.post_id} 内容长度 ${item.content.length} > 80，后备判断显示展开按钮`);
                            }
                        }
                    });
                } catch (error) {
                    console.error(`检查动态 ${item.post_id} 内容高度时出错:`, error);
                    // 出错时的后备判断，使用更低的阈值
                    if (item.content.length > 80) {
                        this.$set(item, 'shouldShowToggle', true);
                        console.log(`动态 ${item.post_id} 检查出错，内容长度 ${item.content.length} > 80，强制显示展开按钮`);
                    }
                }
            });
        },

        // 回退
        goBack() {
            uni.navigateBack({
                delta: 1
            });
        },

        // 获取相册数据（从动态列表中提取）
        fetchAlbumData() {
            this.albumData = {};
            this.dynamicList.forEach(item => {
                if (item.media && item.media.length > 0) {
                    const month = this.formatMonth(item.post_time);
                    if (!this.albumData[month]) {
                        this.albumData[month] = [];
                    }
                    item.media.forEach(media => {
                        this.albumData[month].push({
                            src: media.url,
                            type: media.type,
                            coverUrl: media.coverUrl || '',
                            postId: item.post_id,  // 新增：关联动态ID
                        });
                    });
                }
            });
        },
        // 格式化月份
        formatMonth(dateString) {
            const date = new Date(dateString);
            const month = (date.getMonth() + 1).toString().padStart(2, '0');
            return `${month}月`;
        },
        // 格式化月份
        formatMonth(dateString) {
            const date = new Date(dateString);
            const month = (date.getMonth() + 1).toString().padStart(2, '0');
            return `${month}月`;
        },

        // 开始选择模式并选中当前图片
        startSelectMode(month, photoIndex) {
            // 只有当查看自己的动态时才允许选择删除
            if (this.currentUser === this.targetUserId) {
                this.isSelecting = true;
                this.selectPhoto(month, photoIndex);
            }
        },

        // 选择/取消选择图片
        selectPhoto(month, photoIndex) {
            if (!this.isSelecting) return;

            // 如果当前月份不存在于selectedPhotos中，则初始化一个空数组
            if (!this.selectedPhotos[month]) {
                this.$set(this.selectedPhotos, month, []);
            }

            const photoIndexStr = photoIndex.toString();
            const index = this.selectedPhotos[month].indexOf(photoIndexStr);

            if (index === -1) {
                // 如果未选中，则添加到选中数组
                this.selectedPhotos[month].push(photoIndexStr);
            } else {
                // 如果已选中，则从选中数组中移除
                this.selectedPhotos[month].splice(index, 1);
            }

            // 如果所有选中都被取消，则退出选择模式
            if (this.getSelectedCount() === 0) {
                this.isSelecting = false;
            }
        },

        // 检查图片是否被选中
        isPhotoSelected(month, photoIndex) {
            if (!this.selectedPhotos[month]) return false;
            // 同时检查数字和字符串形式的索引，确保兼容性
            return this.selectedPhotos[month].includes(photoIndex) || this.selectedPhotos[month].includes(photoIndex.toString());
        },

        // 获取选中图片的总数
        getSelectedCount() {
            return Object.values(this.selectedPhotos).reduce((total, indexes) => {
                return total + indexes.length;
            }, 0);
        },

        // 取消选择所有图片
        cancelSelect() {
            this.isSelecting = false;
            // 正确清空响应式对象
            Object.keys(this.selectedPhotos).forEach(key => {
                this.$delete(this.selectedPhotos, key);
            });
        },

        // 打开照片删除弹窗
        openPhotoDeletePopup() {
            if (this.getSelectedCount() > 0) {
                this.$refs.photoDeletePopup.open();
            }
        },
        // 关闭照片删除弹窗
        closePhotoDeletePopup() {
            this.$refs.photoDeletePopup.close();
        },

        // 删除选中的图片及相关动态
        async deleteSelected() {
            console.log("开始删除选中的图片及动态");

            try {
                uni.showLoading({ title: '删除中...' });

                // 1. 收集所有选中照片的postId
                const postIds = new Set();
                const months = Object.keys(this.selectedPhotos);

                for (const month of months) {
                    const indexes = this.selectedPhotos[month].map(Number);
                    for (const index of indexes) {
                        const photo = this.albumData[month][index];
                        if (photo && photo.postId) {
                            postIds.add(photo.postId);
                        }
                    }
                }

                console.log("要删除的动态ID: ", Array.from(postIds));

                // 2. 删除服务器上的动态
                let deleteSuccess = true;
                const deletePromises = Array.from(postIds).map(postId =>
                    request({
                        url: 'discover/Post/delete',
                        method: 'POST',
                        data: { post_id: postId }
                    }).catch(error => {
                        console.error(`删除动态异常: ${postId}`, error);
                        return { code: 0 }; // 标记为失败
                    })
                );

                const results = await Promise.all(deletePromises);
                results.forEach(res => {
                    if (res.code !== 1) {
                        deleteSuccess = false;
                    }
                });

                // 3. 更新本地数据
                if (deleteSuccess) {
                    // 3.1 从相册中删除照片
                    for (const month of months) {
                        // 按降序删除索引
                        const indexes = [...this.selectedPhotos[month]].map(Number).sort((a, b) => b - a);
                        for (const index of indexes) {
                            this.albumData[month].splice(index, 1);
                        }

                        // 如果月份空了则删除
                        if (this.albumData[month].length === 0) {
                            this.$delete(this.albumData, month);
                        }
                    }

                    // 3.2 从动态列表中删除
                    this.dynamicList = this.dynamicList.filter(item => !postIds.has(item.post_id));

                    // 4. 重置状态
                    this.closePhotoDeletePopup();
                    this.isSelecting = false;
                    this.selectedPhotos = {};
                    this.getDynamicList();
                    uni.showToast({ title: '删除成功', icon: 'success' });

                } else {
                    uni.showToast({ title: '部分动态删除失败', icon: 'none' });
                }
            } catch (error) {
                console.error('删除失败:', error);
                uni.showToast({ title: '删除失败', icon: 'none' });
            } finally {
                uni.hideLoading();
            }
        },
        // 获取用户信息并赋值
        async fetchUserInfo(userId = null) {
            try {
                let res;
                if (userId) {
                    // 如果提供了userId，获取指定用户信息
                    res = await request({
                        url: 'User/info',
                        method: 'GET',
                        data: { userid: userId }
                    });
                } else {
                    // 否则获取当前登录用户信息
                    res = await request({
                        url: 'User/info',
                        method: 'GET'
                    });
                }
                if (res.code === 200 && res.data) {
                    // 更新用户信息
                    this.userInfo = {
                        ...this.userInfo,
                        ...res.data,
                        // 确保头像路径正确
                        avatar: res.data.avatar || "/static/image/logo.jpg"
                    };
                    this.userInfo.selfDesc = res.data.bio || ""
                    this.currentBgImage = res.data.background_image || ""
                    console.log("获取用户信息成功:", this.userInfo);
                } else {
                    uni.showToast({
                        title: res.msg || '获取用户信息失败',
                        icon: 'none'
                    });
                }
            } catch (error) {
                console.error('获取用户信息失败:', error);
                uni.showToast({
                    title: '网络错误',
                    icon: 'none'
                });
            }
        },
        // 统一处理视频时长更新，兼容两种参数格式
        updateVideoDuration(e, item, param1, param2) {
            const videoEl = e.target;
            // 添加日志调试
            console.log('updateVideoDuration called with:', item, param1, param2);

            if (videoEl && videoEl.duration) {
                console.log('Video duration detected:', videoEl.duration);
                // 检查是哪种调用格式：
                // 1. 格式1: (e, item, index, mediaIndex) - 处理media对象中的视频
                // 2. 格式2: (e, item, month, photoIndex) - 处理直接的视频项
                if (item.media && item.media[param2] !== undefined) {
                    // 格式1：更新media对象中的视频时长
                    this.$set(item.media[param2], 'duration', videoEl.duration);
                } else {
                    // 格式2：直接更新item的duration属性
                    this.$set(item, 'duration', videoEl.duration);
                    console.log('Duration set to item:', item.duration);
                }
            } else {
                console.log('No valid video element or duration');
                // 作为备选方案，为了显示效果，我们可以设置一个默认时长
                if (!item.duration && item.type === 'video') {
                    this.$set(item, 'duration', 60); // 默认60秒
                    console.log('Set default duration for video item');
                }
            }
        },

        // 处理视频点击事件
        handleVideoClick(e, item, index, mediaIndex) {
            e.stopPropagation();
            this.openVideoViewer(item, mediaIndex);
        },

        // 格式化视频时长
        formatVideoDuration(seconds) {
            console.log("时长", seconds)
            if (!seconds) return '00:00';
            const mins = Math.floor(seconds / 60);
            const secs = Math.floor(seconds % 60);
            return `${mins.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`;
        },

        // 播放视频
        playVideo(item, month, photoIndex) {
            if (!this.isSelecting) {
                // 在非选择模式下播放视频
                uni.navigateTo({
                    url: `/pages/discover/videView/videView?videoUrl=${encodeURIComponent(item.src)}`
                });
            } else {
                // 在选择模式下选择视频
                this.selectPhoto(month, photoIndex);
            }
        },

        // 查看照片
        viewPhoto(item) {
            // 显示照片查看器
            this.showViewer = true;
            this.viewerData = item;
        },
    },
    mounted() {

        // 增加检测重试机制
        const checkWithRetry = (retryCount = 0) => {
            this.checkContentLength();
            if (retryCount < 3) {
                setTimeout(() => checkWithRetry(retryCount + 1), 300);
            }
        };
        checkWithRetry();
    },
    onShow() {
        this.checkContentLength();
    },

    updated() {
        setTimeout(() => {
            this.checkContentLength();
        }, 300);
    },

};